

"""记录python的各类内置函数的用法"""

# abs()绝对值函数abs():输出参数的绝对值
abs(-40)

# dict()创建字典
dict()  #创建空字典
dict(a='a', b='b', t='t')   #{'a': 'a', 'b': 'b', 't': 't'}键值对创建字典
dict(zip(['one', 'two', 'three'], [1, 2, 3]))   #{'three': 3, 'two': 2, 'one': 1}映射函数方式来构造字典
dict([('one', 1), ('two', 2), ('three', 3)])    #{'three': 3, 'two': 2, 'one': 1}可迭代对象方式来构造字典

# min() 方法返回给定参数的最小值，参数可以为序列
min(1,2,3,4)    #参数是数值
min([1,2,3,4])  #参数是列表

# setattr()/getattr():  设置和获取对象的属性值
# hasattr() 函数用于判断对象是否包含对应的属性。
# delattr() 函数用于删除属性。
# setattr(object, name, value)
class A(object):
    bar = 1
a=A()
# setattr()
setattr(a,'bar',5)  #设置bar的值为5
setattr(a,'age',28) #设置a的一个属性age=28
# getattr()
getattr(a, 'bar')   #获取bar的值
getattr(a, 'name')   #属性name不存在,触发异常
getattr(a, 'name','Tom')   #属性name不存在,但是设置了默认值'Tom'
hasattr(a, 'name')   #属性name不存在,返回 false
hasattr(a, 'bar')   #属性bar存在,返回 true
delattr(a, 'bar')   #删除bar属性

# all() 判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False
all(['a', 'b', 'c', 'd'])   #返回True,有一个为False属性就返回false
all((0, 1, 2, 3))       #返回false
# all([])/all(()) 空列表和空元祖都返回true

# any() 判断给定的可迭代参数 iterable 中的所有元素是否都为 false，如果是返回 false，否则返回 true
# 取或逻辑,效果与all()类似

# dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
dir()   #  获得当前模块的属性列表  ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
dir([ ])    # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

# hex() 函数用于将一个指定数字转换为 16 进制数
hex(255)    #将十进制的255转成16进制'0xff',类型是字符串

# next((iterator[, default])   返回迭代器的下一个项目
# next(it,[8])  设置默认值
it = iter([1,2,3,4,5])
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

# slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。切片操作的底层实现
# class slice(stop)
# class slice(start, stop[, step])
myslice = slice(2,7,2)
arr=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr[myslice]    #等价于arr[2:7:2]

# divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b),除法和求余数的底层实现。
divmod(7, 2)    #(3, 1) python 3.x 版本该函数不支持复数

# id() 函数用于获取对象的内存地址。

# sorted() 函数对所有可迭代的对象进行排序操作。
# sort 与 sorted 区别：
# sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
# list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
# sorted(iterable, key=None, reverse=False)  reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认
a=[5, 2, 3, 1, 4]
sorted(a)   # 不修改原来的list
a.sort()    # 修改了原来的list
sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'},key=lambda x:x**-1,reverse=True)    # [1, 2, 3, 4, 5]

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# enumerate(sequence, [start=0])  sequence -- 一个序列、迭代器或其他支持迭代对象    start -- 下标起始位置。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons, start=1))       # 小标从 1 开始  [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)   # 0 one  1 two   2 three

# input() 函数接受一个标准输入数据，返回为 string 类型

# oct() 函数将一个整数转换成8进制字符串。
oct(10)     # '012'

# python staticmethod 返回函数的静态方法。
# staticmethod(function)
class C(object):
    @staticmethod
    def f():
        print('runoob')
C.f()  # 静态方法无需实例化
cobj = C()
cobj.f()    # 也可以实例化后调用

# bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
bin(10)     #'0b1010'

# eval() 函数用来执行一个字符串表达式，并返回表达式的值。
x = 7
eval( '3 * x' ) # 21
eval({'a':1,'b':2}) # {'a':1,'b':2}

# exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码
# exec(object[, globals[, locals]])
exec('print("Hello World")')        # Hello World

# int() 函数用于将一个字符串或数字转换为整型。
# class int(x, base=10)   x -- 字符串或数字    base -- 进制数，默认十进制。
int('10',8)     # 8

# bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool(0)     # False
bool(1)     # True
issubclass(bool, int)  # bool 是 int 子类

# open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# file: 必需，文件路径（相对或者绝对路径）。
# mode: 可选，文件打开模式
# buffering: 设置缓冲
# encoding: 一般使用utf8
# errors: 报错级别
# newline: 区分换行符
# closefd: 传入的file参数类型
# opener:
f = open('test.txt')
f.read()

# isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
# isinstance() 与 type() 区别：type() 不会认为子类是一种父类类型，不考虑继承关系/isinstance() 会认为子类是一种父类类型，考虑继承关系。/如果要判断两个类型是否相同推荐使用 isinstance()。
# isinstance(object, classinfo)
isinstance (2,int)      # True
isinstance (2,(str,int,list))    # 是元组中的一个返回 True

# ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
ord('a')    # 97

# sum() 方法对系列进行求和计算。
sum([0,1,2])    # 3
sum((2, 3, 4), 1)   # 元组计算总和后再加 1 .   10

# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
# filter(function, iterable)
def is_odd(n):
    return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)     # [1, 3, 5, 7, 9]

# issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
# issubclass(class, classinfo)
class A:
    pass
class B(A):
    pass
issubclass(B,A)     # 返回 True

# pow() 方法返回 xy（x的y次方） 的值。
# pow(x, y[, z])  函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
pow(100, 2)     #10000
pow(100, 2 ,3)     #1 对结果取模
import math   # 导入 math 模块
math.pow(100, 2)    # 10000.0   math.pow()结果是float,而pow()的结果是整形.

# super() 函数是用于调用父类(超类)的一个方法。
class A():
    def __init__(self):
        print('enter A')
        print('leave A')

class B(A):
    def __init__(self):
        print('enter B')
        super().__init__()
        print('leave B')

class C(A):
    def __init__(self):
        print('enter C')
        super().__init__()
        print('leave C')

class D(B, C):
    def __init__(self):
        print('enter D')
        super().__init__()
        print('leave D')

# enter D
# enter B
# enter C
# enter A
# leave A
# leave C
# leave B
# leave D

# float() 函数用于将整数和字符串转换成浮点数。
float(1)        # 1.0

# iter() 函数用来生成迭代器。
lst = [1, 2, 3]
for i in iter(lst):
    print(i)

# tuple 函数将列表转换为元组。
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)     # ('Google', 'Taobao', 'Runoob', 'Baidu')

# callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
# 对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
callable(0)     # False
a = A()
callable(a)               # 没有实现 __call__, 返回 False
class B:
    def __call__(self):
        return 0
callable(B)     # True

# format() 函数可以接受不限个参数，位置可以不按顺序。
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序     'hello world'
"{1} {0} {1}".format("hello", "world")  # 设置指定位置    'world hello world'
"网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")    # 网站名：菜鸟教程, 地址 www.runoob.com
site = {"name": "菜鸟教程", "url": "www.runoob.com"}    # 通过列表索引设置参数
"网站名：{name}, 地址 {url}".format(**site)   # 网站名：菜鸟教程, 地址 www.runoob.com
my_list = ['菜鸟教程', 'www.runoob.com']
"网站名：{0[0]}, 地址 {0[1]}".format(my_list)     # "0" 是必须的    网站名：菜鸟教程, 地址 www.runoob.com

# len() 方法返回对象（字符、列表、元组等）长度或项目个数。
len([1,2,3,4,5])        # 列表元素个数

# property() 函数的作用是在新式类中返回属性值。      作用暂不详

# type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
type(1)     # <type 'int'>
X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X   <class '__main__.X'>

# chr() 用一个整数作参数，返回一个对应的字符。
chr(0x30)       # '0'
chr(97)         # 'a'
chr(8364)       # '€'

# frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])       # 创建不可变集合

# list() 方法用于将元组或字符串转换为列表。
list("Hello World")     # ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
list((123, 'Google', 'Runoob', 'Taobao'))       # [123, 'Google', 'Runoob', 'Taobao']

# range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
list(range(5))      # list(range(5))

# vars() 函数返回对象object的属性和属性值的字典对象。
class Runoob:
    a = 1
# {'a': 1, '__module__': '__main__', '__doc__': None}

# classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
class A(object):
    bar = 1
    def func1(self):
        print ('foo')
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
A.func2()               # 不需要实例化
class A(object):

    # 属性默认为类属性（可以给直接被类本身调用）
    num = "类属性"

    # 实例化方法（必须实例化类之后才能被调用）
    def func1(self): # self : 表示实例化类后的地址id
        print("func1")
        print(self)

    # 类方法（不需要实例化类就可以被类本身调用）
    @classmethod
    def func2(cls):  # cls : 表示没用被实例化的类本身
        print("func2")
        print(cls)
        print(cls.num)
        cls().func1()

    # 静态方法.不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）?
    def func3():
        print("func3")
        print(A.num) # 属性是可以直接用类本身调用的
a=A()
a.func1()
A.func2()
A.func3()

# locals() 函数会以字典类型返回当前位置的全部局部变量。
# 对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
def runoob(arg):    # 两个局部变量：arg、z
    z = 1
    print (locals())
runoob(4)       # {'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
# globals() 函数会以字典类型返回当前位置的全部全局变量。
a='runoob'
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
# {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

# repr() 函数将对象转化为供解释器读取的形式。
repr('RUNOOB')      # "'RUNOOB'"
repr({'runoob': 'runoob.com', 'google': 'google.com'})  # "{'google': 'google.com', 'runoob': 'runoob.com'}"

# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
# 我们可以使用 list() 转换来输出列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a1= [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
rec = list(zip(a1,b,c))     #[(1, 4, 4), (2, 5, 5), (3, 6, 6)]
d= [(1, 4, 4), (2, 5, 5), (3, 6, 6)]
r1,r2,r3 = zip(*d)      # r1:(1, 2, 3) r2:(4, 5, 6) r3:(4, 5, 6)

# compile() 函数将一个字符串编译为字节代码。    作用不详

# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
def square(x) :            # 计算平方数
    return x ** 2
map(square, [1,2,3,4,5])   # 计算列表各个元素的平方  [1, 4, 9, 16, 25]
map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数        [1, 4, 9, 16, 25]
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])  # 提供了两个列表，对相同位置的列表数据进行相加  [3, 7, 11, 15, 19]

# reversed 函数返回一个反转的迭代器。
print(list(reversed('Runoob')))     # ['b', 'o', 'o', 'n', 'u', 'R']
print(list(reversed([1, 2, 4, 3, 5])))      # [5, 3, 4, 2, 1]

# __import__() 函数用于动态加载类和函数 。
# 如果一个模块经常变化就可以使用 __import__() 来动态载入。
# a.py文件
import os
print('在 a.py 文件中 %s' % id(os))
# test.py文件
import sys
__import__('a')        # 导入 a.py 模块     在 a.py 文件中 4394716136

# complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
complex(1, 2)       # (1 + 2j)
complex(1)      # (1 + 0j)
complex("1")  # 当做字符串处理     (1 + 0j)
complex("1+2j")     # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 (1 + 2j)

# max() 方法返回给定参数的最大值，参数可以为序列。
max(80, 100, 1000)      # 1000

# round() 方法返回浮点数x的四舍五入值。
round(70.23456)     # 70
round(80.264, 2)    # 80.26

# hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
hash('test')            # 字符串   2314058222102390712

# memoryview() 函数返回给定参数的内存查看对象(Momory view)。
# 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])     # 98

# set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
x = set('runoob')
y = set('google')
x & y   # 交集
x | y   # 并集
x - y   # 差集